home *** CD-ROM | disk | FTP | other *** search
/ PC World 2007 June / PCWorld_2007-06_cd.bin / zabezpeceni / spyeraser / spyeraser.exe / {app} / SpyEraser.dll / 2110 / CALENDAR.JS < prev    next >
Text File  |  2007-04-23  |  48KB  |  1,703 lines
  1.  
  2. /** The Calendar object constructor. */
  3. Calendar = function (firstDayOfWeek, dateStr, onSelected, onClose) {
  4.     // member variables
  5.     this.activeDiv = null;
  6.     this.currentDateEl = null;
  7.     this.getDateStatus = null;
  8.     this.timeout = null;
  9.     this.onSelected = onSelected || null;
  10.     this.onClose = onClose || null;
  11.     this.dragging = false;
  12.     this.hidden = false;
  13.     this.minYear = 1970;
  14.     this.maxYear = 2050;
  15.     this.dateFormat = Calendar._TT["DEF_DATE_FORMAT"];
  16.     this.ttDateFormat = Calendar._TT["TT_DATE_FORMAT"];
  17.     this.isPopup = true;
  18.     this.weekNumbers = true;
  19.     this.firstDayOfWeek = firstDayOfWeek; // 0 for Sunday, 1 for Monday, etc.
  20.     this.showsOtherMonths = false;
  21.     this.dateStr = dateStr;
  22.     this.ar_days = null;
  23.     this.showsTime = false;
  24.     this.time24 = true;
  25.     this.yearStep = 2;
  26.     // HTML elements
  27.     this.table = null;
  28.     this.element = null;
  29.     this.tbody = null;
  30.     this.firstdayname = null;
  31.     // Combo boxes
  32.     this.monthsCombo = null;
  33.     this.yearsCombo = null;
  34.     this.hilitedMonth = null;
  35.     this.activeMonth = null;
  36.     this.hilitedYear = null;
  37.     this.activeYear = null;
  38.     // Information
  39.     this.dateClicked = false;
  40.  
  41.     // one-time initializations
  42.     if (typeof Calendar._SDN == "undefined") {
  43.         // table of short day names
  44.         if (typeof Calendar._SDN_len == "undefined")
  45.             Calendar._SDN_len = 3;
  46.         var ar = new Array();
  47.         for (var i = 8; i > 0;) {
  48.             ar[--i] = Calendar._DN[i].substr(0, Calendar._SDN_len);
  49.         }
  50.         Calendar._SDN = ar;
  51.         // table of short month names
  52.         if (typeof Calendar._SMN_len == "undefined")
  53.             Calendar._SMN_len = 3;
  54.         ar = new Array();
  55.         for (var i = 12; i > 0;) {
  56.             ar[--i] = Calendar._MN[i].substr(0, Calendar._SMN_len);
  57.         }
  58.         Calendar._SMN = ar;
  59.     }
  60. };
  61.  
  62. // ** constants
  63.  
  64. /// "static", needed for event handlers.
  65. Calendar._C = null;
  66.  
  67. /// detect a special case of "web browser"
  68. Calendar.is_ie = ( /msie/i.test(navigator.userAgent) &&
  69.            !/opera/i.test(navigator.userAgent) );
  70.  
  71. Calendar.is_ie5 = ( Calendar.is_ie && /msie 5\.0/i.test(navigator.userAgent) );
  72.  
  73. /// detect Opera browser
  74. Calendar.is_opera = /opera/i.test(navigator.userAgent);
  75.  
  76. /// detect KHTML-based browsers
  77. Calendar.is_khtml = /Konqueror|Safari|KHTML/i.test(navigator.userAgent);
  78.  
  79. // BEGIN: UTILITY FUNCTIONS; beware that these might be moved into a separate
  80. //        library, at some point.
  81.  
  82. Calendar.getAbsolutePos = function(el) {
  83.     var SL = 0, ST = 0;
  84.     var is_div = /^div$/i.test(el.tagName);
  85.     if (is_div && el.scrollLeft)
  86.         SL = el.scrollLeft;
  87.     if (is_div && el.scrollTop)
  88.         ST = el.scrollTop;
  89.     var r = { x: el.offsetLeft - SL, y: el.offsetTop - ST };
  90.     if (el.offsetParent) {
  91.         var tmp = this.getAbsolutePos(el.offsetParent);
  92.         r.x += tmp.x;
  93.         r.y += tmp.y;
  94.     }
  95.     return r;
  96. };
  97.  
  98. Calendar.isRelated = function (el, evt) {
  99.     var related = evt.relatedTarget;
  100.     if (!related) {
  101.         var type = evt.type;
  102.         if (type == "mouseover") {
  103.             related = evt.fromElement;
  104.         } else if (type == "mouseout") {
  105.             related = evt.toElement;
  106.         }
  107.     }
  108.     while (related) {
  109.         if (related == el) {
  110.             return true;
  111.         }
  112.         related = related.parentNode;
  113.     }
  114.     return false;
  115. };
  116.  
  117. Calendar.removeClass = function(el, className) {
  118.     if (!(el && el.className)) {
  119.         return;
  120.     }
  121.     var cls = el.className.split(" ");
  122.     var ar = new Array();
  123.     for (var i = cls.length; i > 0;) {
  124.         if (cls[--i] != className) {
  125.             ar[ar.length] = cls[i];
  126.         }
  127.     }
  128.     el.className = ar.join(" ");
  129. };
  130.  
  131. Calendar.addClass = function(el, className) {
  132.     Calendar.removeClass(el, className);
  133.     el.className += " " + className;
  134. };
  135.  
  136. Calendar.getElement = function(ev) {
  137.     if (Calendar.is_ie) {
  138.         return window.event.srcElement;
  139.     } else {
  140.         return ev.currentTarget;
  141.     }
  142. };
  143.  
  144. Calendar.getTargetElement = function(ev) {
  145.     if (Calendar.is_ie) {
  146.         return window.event.srcElement;
  147.     } else {
  148.         return ev.target;
  149.     }
  150. };
  151.  
  152. Calendar.stopEvent = function(ev) {
  153.     ev || (ev = window.event);
  154.     if (Calendar.is_ie) {
  155.         ev.cancelBubble = true;
  156.         ev.returnValue = false;
  157.     } else {
  158.         ev.preventDefault();
  159.         ev.stopPropagation();
  160.     }
  161.     return false;
  162. };
  163.  
  164. Calendar.addEvent = function(el, evname, func) {
  165.     if (el.attachEvent) { // IE
  166.         el.attachEvent("on" + evname, func);
  167.     } else if (el.addEventListener) { // Gecko / W3C
  168.         el.addEventListener(evname, func, true);
  169.     } else {
  170.         el["on" + evname] = func;
  171.     }
  172. };
  173.  
  174. Calendar.removeEvent = function(el, evname, func) {
  175.     if (el.detachEvent) { // IE
  176.         el.detachEvent("on" + evname, func);
  177.     } else if (el.removeEventListener) { // Gecko / W3C
  178.         el.removeEventListener(evname, func, true);
  179.     } else {
  180.         el["on" + evname] = null;
  181.     }
  182. };
  183.  
  184. Calendar.createElement = function(type, parent) {
  185.     var el = null;
  186.     if (document.createElementNS) {
  187.         // use the XHTML namespace; IE won't normally get here unless
  188.         // _they_ "fix" the DOM2 implementation.
  189.         el = document.createElementNS("http://www.w3.org/1999/xhtml", type);
  190.     } else {
  191.         el = document.createElement(type);
  192.     }
  193.     if (typeof parent != "undefined") {
  194.         parent.appendChild(el);
  195.     }
  196.     return el;
  197. };
  198.  
  199. // END: UTILITY FUNCTIONS
  200.  
  201. // BEGIN: CALENDAR STATIC FUNCTIONS
  202.  
  203. /** Internal -- adds a set of events to make some element behave like a button. */
  204. Calendar._add_evs = function(el) {
  205.     with (Calendar) {
  206.         addEvent(el, "mouseover", dayMouseOver);
  207.         addEvent(el, "mousedown", dayMouseDown);
  208.         addEvent(el, "mouseout", dayMouseOut);
  209.         if (is_ie) {
  210.             addEvent(el, "dblclick", dayMouseDblClick);
  211.             el.setAttribute("unselectable", true);
  212.         }
  213.     }
  214. };
  215.  
  216. Calendar.findMonth = function(el) {
  217.     if (typeof el.month != "undefined") {
  218.         return el;
  219.     } else if (typeof el.parentNode.month != "undefined") {
  220.         return el.parentNode;
  221.     }
  222.     return null;
  223. };
  224.  
  225. Calendar.findYear = function(el) {
  226.     if (typeof el.year != "undefined") {
  227.         return el;
  228.     } else if (typeof el.parentNode.year != "undefined") {
  229.         return el.parentNode;
  230.     }
  231.     return null;
  232. };
  233.  
  234. Calendar.showMonthsCombo = function () {
  235.     var cal = Calendar._C;
  236.     if (!cal) {
  237.         return false;
  238.     }
  239.     var cal = cal;
  240.     var cd = cal.activeDiv;
  241.     var mc = cal.monthsCombo;
  242.     if (cal.hilitedMonth) {
  243.         Calendar.removeClass(cal.hilitedMonth, "hilite");
  244.     }
  245.     if (cal.activeMonth) {
  246.         Calendar.removeClass(cal.activeMonth, "active");
  247.     }
  248.     var mon = cal.monthsCombo.getElementsByTagName("div")[cal.date.getMonth()];
  249.     Calendar.addClass(mon, "active");
  250.     cal.activeMonth = mon;
  251.     var s = mc.style;
  252.     s.display = "block";
  253.     if (cd.navtype < 0)
  254.         s.left = cd.offsetLeft + "px";
  255.     else {
  256.         var mcw = mc.offsetWidth;
  257.         if (typeof mcw == "undefined")
  258.             // Konqueror brain-dead techniques
  259.             mcw = 50;
  260.         s.left = (cd.offsetLeft + cd.offsetWidth - mcw) + "px";
  261.     }
  262.     s.top = (cd.offsetTop + cd.offsetHeight) + "px";
  263. };
  264.  
  265. Calendar.showYearsCombo = function (fwd) {
  266.     var cal = Calendar._C;
  267.     if (!cal) {
  268.         return false;
  269.     }
  270.     var cal = cal;
  271.     var cd = cal.activeDiv;
  272.     var yc = cal.yearsCombo;
  273.     if (cal.hilitedYear) {
  274.         Calendar.removeClass(cal.hilitedYear, "hilite");
  275.     }
  276.     if (cal.activeYear) {
  277.         Calendar.removeClass(cal.activeYear, "active");
  278.     }
  279.     cal.activeYear = null;
  280.     var Y = cal.date.getFullYear() + (fwd ? 1 : -1);
  281.     var yr = yc.firstChild;
  282.     var show = false;
  283.     for (var i = 12; i > 0; --i) {
  284.         if (Y >= cal.minYear && Y <= cal.maxYear) {
  285.             yr.firstChild.data = Y;
  286.             yr.year = Y;
  287.             yr.style.display = "block";
  288.             show = true;
  289.         } else {
  290.             yr.style.display = "none";
  291.         }
  292.         yr = yr.nextSibling;
  293.         Y += fwd ? cal.yearStep : -cal.yearStep;
  294.     }
  295.     if (show) {
  296.         var s = yc.style;
  297.         s.display = "block";
  298.         if (cd.navtype < 0)
  299.             s.left = cd.offsetLeft + "px";
  300.         else {
  301.             var ycw = yc.offsetWidth;
  302.             if (typeof ycw == "undefined")
  303.                 // Konqueror brain-dead techniques
  304.                 ycw = 50;
  305.             s.left = (cd.offsetLeft + cd.offsetWidth - ycw) + "px";
  306.         }
  307.         s.top = (cd.offsetTop + cd.offsetHeight) + "px";
  308.     }
  309. };
  310.  
  311. // event handlers
  312.  
  313. Calendar.tableMouseUp = function(ev) {
  314.     var cal = Calendar._C;
  315.     if (!cal) {
  316.         return false;
  317.     }
  318.     if (cal.timeout) {
  319.         clearTimeout(cal.timeout);
  320.     }
  321.     var el = cal.activeDiv;
  322.     if (!el) {
  323.         return false;
  324.     }
  325.     var target = Calendar.getTargetElement(ev);
  326.     ev || (ev = window.event);
  327.     Calendar.removeClass(el, "active");
  328.     if (target == el || target.parentNode == el) {
  329.         Calendar.cellClick(el, ev);
  330.     }
  331.     var mon = Calendar.findMonth(target);
  332.     var date = null;
  333.     if (mon) {
  334.         date = new Date(cal.date);
  335.         if (mon.month != date.getMonth()) {
  336.             date.setMonth(mon.month);
  337.             cal.setDate(date);
  338.             cal.dateClicked = false;
  339.             cal.callHandler();
  340.         }
  341.     } else {
  342.         var year = Calendar.findYear(target);
  343.         if (year) {
  344.             date = new Date(cal.date);
  345.             if (year.year != date.getFullYear()) {
  346.                 date.setFullYear(year.year);
  347.                 cal.setDate(date);
  348.                 cal.dateClicked = false;
  349.                 cal.callHandler();
  350.             }
  351.         }
  352.     }
  353.     with (Calendar) {
  354.         removeEvent(document, "mouseup", tableMouseUp);
  355.         removeEvent(document, "mouseover", tableMouseOver);
  356.         removeEvent(document, "mousemove", tableMouseOver);
  357.         cal._hideCombos();
  358.         _C = null;
  359.         return stopEvent(ev);
  360.     }
  361. };
  362.  
  363. Calendar.tableMouseOver = function (ev) {
  364.     var cal = Calendar._C;
  365.     if (!cal) {
  366.         return;
  367.     }
  368.     var el = cal.activeDiv;
  369.     var target = Calendar.getTargetElement(ev);
  370.     if (target == el || target.parentNode == el) {
  371.         Calendar.addClass(el, "hilite active");
  372.         Calendar.addClass(el.parentNode, "rowhilite");
  373.     } else {
  374.         if (typeof el.navtype == "undefined" || (el.navtype != 50 && (el.navtype == 0 || Math.abs(el.navtype) > 2)))
  375.             Calendar.removeClass(el, "active");
  376.         Calendar.removeClass(el, "hilite");
  377.         Calendar.removeClass(el.parentNode, "rowhilite");
  378.     }
  379.     ev || (ev = window.event);
  380.     if (el.navtype == 50 && target != el) {
  381.         var pos = Calendar.getAbsolutePos(el);
  382.         var w = el.offsetWidth;
  383.         var x = ev.clientX;
  384.         var dx;
  385.         var decrease = true;
  386.         if (x > pos.x + w) {
  387.             dx = x - pos.x - w;
  388.             decrease = false;
  389.         } else
  390.             dx = pos.x - x;
  391.  
  392.         if (dx < 0) dx = 0;
  393.         var range = el._range;
  394.         var current = el._current;
  395.         var count = Math.floor(dx / 10) % range.length;
  396.         for (var i = range.length; --i >= 0;)
  397.             if (range[i] == current)
  398.                 break;
  399.         while (count-- > 0)
  400.             if (decrease) {
  401.                 if (--i < 0)
  402.                     i = range.length - 1;
  403.             } else if ( ++i >= range.length )
  404.                 i = 0;
  405.         var newval = range[i];
  406.         el.firstChild.data = newval;
  407.  
  408.         cal.onUpdateTime();
  409.     }
  410.     var mon = Calendar.findMonth(target);
  411.     if (mon) {
  412.         if (mon.month != cal.date.getMonth()) {
  413.             if (cal.hilitedMonth) {
  414.                 Calendar.removeClass(cal.hilitedMonth, "hilite");
  415.             }
  416.             Calendar.addClass(mon, "hilite");
  417.             cal.hilitedMonth = mon;
  418.         } else if (cal.hilitedMonth) {
  419.             Calendar.removeClass(cal.hilitedMonth, "hilite");
  420.         }
  421.     } else {
  422.         if (cal.hilitedMonth) {
  423.             Calendar.removeClass(cal.hilitedMonth, "hilite");
  424.         }
  425.         var year = Calendar.findYear(target);
  426.         if (year) {
  427.             if (year.year != cal.date.getFullYear()) {
  428.                 if (cal.hilitedYear) {
  429.                     Calendar.removeClass(cal.hilitedYear, "hilite");
  430.                 }
  431.                 Calendar.addClass(year, "hilite");
  432.                 cal.hilitedYear = year;
  433.             } else if (cal.hilitedYear) {
  434.                 Calendar.removeClass(cal.hilitedYear, "hilite");
  435.             }
  436.         } else if (cal.hilitedYear) {
  437.             Calendar.removeClass(cal.hilitedYear, "hilite");
  438.         }
  439.     }
  440.     return Calendar.stopEvent(ev);
  441. };
  442.  
  443. Calendar.tableMouseDown = function (ev) {
  444.     if (Calendar.getTargetElement(ev) == Calendar.getElement(ev)) {
  445.         return Calendar.stopEvent(ev);
  446.     }
  447. };
  448.  
  449. Calendar.calDragIt = function (ev) {
  450.     var cal = Calendar._C;
  451.     if (!(cal && cal.dragging)) {
  452.         return false;
  453.     }
  454.     var posX;
  455.     var posY;
  456.     if (Calendar.is_ie) {
  457.         posY = window.event.clientY + document.body.scrollTop;
  458.         posX = window.event.clientX + document.body.scrollLeft;
  459.     } else {
  460.         posX = ev.pageX;
  461.         posY = ev.pageY;
  462.     }
  463.     cal.hideShowCovered();
  464.     var st = cal.element.style;
  465.     st.left = (posX - cal.xOffs) + "px";
  466.     st.top = (posY - cal.yOffs)+ "px";
  467.     return Calendar.stopEvent(ev);
  468. };
  469.  
  470. Calendar.calDragEnd = function (ev) {
  471.     var cal = Calendar._C;
  472.     if (!cal) {
  473.         return false;
  474.     }
  475.     cal.dragging = false;
  476.     with (Calendar) {
  477.         removeEvent(document, "mousemove", calDragIt);
  478.         removeEvent(document, "mouseup", calDragEnd);
  479.         tableMouseUp(ev);
  480.     }
  481.     cal.hideShowCovered();
  482. };
  483.  
  484. Calendar.dayMouseDown = function(ev) {
  485.     var el = Calendar.getElement(ev);
  486.     if (el.disabled) {
  487.         return false;
  488.     }
  489.     var cal = el.calendar;
  490.     cal.activeDiv = el;
  491.     Calendar._C = cal;
  492.     if (el.navtype != 300) with (Calendar) {
  493.         if (el.navtype == 50) {
  494.             el._current = el.firstChild.data;
  495.             addEvent(document, "mousemove", tableMouseOver);
  496.         } else
  497.             addEvent(document, Calendar.is_ie5 ? "mousemove" : "mouseover", tableMouseOver);
  498.         addClass(el, "hilite active");
  499.         addEvent(document, "mouseup", tableMouseUp);
  500.     } else if (cal.isPopup) {
  501.         cal._dragStart(ev);
  502.     }
  503.     if (el.navtype == -1 || el.navtype == 1) {
  504.         if (cal.timeout) clearTimeout(cal.timeout);
  505.         cal.timeout = setTimeout("Calendar.showMonthsCombo()", 250);
  506.     } else if (el.navtype == -2 || el.navtype == 2) {
  507.         if (cal.timeout) clearTimeout(cal.timeout);
  508.         cal.timeout = setTimeout((el.navtype > 0) ? "Calendar.showYearsCombo(true)" : "Calendar.showYearsCombo(false)", 250);
  509.     } else {
  510.         cal.timeout = null;
  511.     }
  512.     return Calendar.stopEvent(ev);
  513. };
  514.  
  515. Calendar.dayMouseDblClick = function(ev) {
  516.     Calendar.cellClick(Calendar.getElement(ev), ev || window.event);
  517.     if (Calendar.is_ie) {
  518.         document.selection.empty();
  519.     }
  520. };
  521.  
  522. Calendar.dayMouseOver = function(ev) {
  523.     var el = Calendar.getElement(ev);
  524.     if (Calendar.isRelated(el, ev) || Calendar._C || el.disabled) {
  525.         return false;
  526.     }
  527.     if (el.ttip) {
  528.         if (el.ttip.substr(0, 1) == "_") {
  529.             el.ttip = el.caldate.print(el.calendar.ttDateFormat) + el.ttip.substr(1);
  530.         }
  531.         el.calendar.tooltips.firstChild.data = el.ttip;
  532.     }
  533.     if (el.navtype != 300) {
  534.         Calendar.addClass(el, "hilite");
  535.         if (el.caldate) {
  536.             Calendar.addClass(el.parentNode, "rowhilite");
  537.         }
  538.     }
  539.     return Calendar.stopEvent(ev);
  540. };
  541.  
  542. Calendar.dayMouseOut = function(ev) {
  543.     with (Calendar) {
  544.         var el = getElement(ev);
  545.         if (isRelated(el, ev) || _C || el.disabled) {
  546.             return false;
  547.         }
  548.         removeClass(el, "hilite");
  549.         if (el.caldate) {
  550.             removeClass(el.parentNode, "rowhilite");
  551.         }
  552.         el.calendar.tooltips.firstChild.data = _TT["SEL_DATE"];
  553.         return stopEvent(ev);
  554.     }
  555. };
  556.  
  557. /**
  558.  *  A generic "click" handler :) handles all types of buttons defined in this
  559.  *  calendar.
  560.  */
  561. Calendar.cellClick = function(el, ev) {
  562.     var cal = el.calendar;
  563.     var closing = false;
  564.     var newdate = false;
  565.     var date = null;
  566.     if (typeof el.navtype == "undefined") {
  567.         Calendar.removeClass(cal.currentDateEl, "selected");
  568.         Calendar.addClass(el, "selected");
  569.         closing = (cal.currentDateEl == el);
  570.         if (!closing) {
  571.             cal.currentDateEl = el;
  572.         }
  573.         cal.date = new Date(el.caldate);
  574.         date = cal.date;
  575.         newdate = true;
  576.         // a date was clicked
  577.         if (!(cal.dateClicked = !el.otherMonth))
  578.             cal._init(cal.firstDayOfWeek, date);
  579.     } else {
  580.         if (el.navtype == 200) {
  581.             Calendar.removeClass(el, "hilite");
  582.             cal.callCloseHandler();
  583.             return;
  584.         }
  585.         date = (el.navtype == 0) ? new Date() : new Date(cal.date);
  586.         // unless "today" was clicked, we assume no date was clicked so
  587.         // the selected handler will know not to close the calenar when
  588.         // in single-click mode.
  589.         // cal.dateClicked = (el.navtype == 0);
  590.         cal.dateClicked = false;
  591.         var year = date.getFullYear();
  592.         var mon = date.getMonth();
  593.         function setMonth(m) {
  594.             var day = date.getDate();
  595.             var max = date.getMonthDays(m);
  596.             if (day > max) {
  597.                 date.setDate(max);
  598.             }
  599.             date.setMonth(m);
  600.         };
  601.         switch (el.navtype) {
  602.             case 400:
  603.             Calendar.removeClass(el, "hilite");
  604.             var text = Calendar._TT["BOUT"];
  605.             if (typeof text != "undefined") {
  606.                 text += cal.showsTime ? Calendar._TT["ABOUT_TIME"] : "";
  607.             } else {
  608.                 // FIXME: this should be removed as soon as lang files get updated!
  609.                 text = "Help and about box text is not translated into this language.\n" +
  610.                     "If you know this language and you feel generous please update\n" +
  611.                     "the corresponding file in \"lang\" subdir to match calendar-en.js\n" +
  612.                     "and send it back to <mishoo@infoiasi.ro> to get it into the distribution  ;-)\n\n" +
  613.                     "Thank you!\n" +
  614.                     "http://dynarch.com/mishoo/calendar.epl\n";
  615.             }
  616.             alert(text);
  617.             return;
  618.             case -2:
  619.             if (year > cal.minYear) {
  620.                 date.setFullYear(year - 1);
  621.             }
  622.             break;
  623.             case -1:
  624.             if (mon > 0) {
  625.                 setMonth(mon - 1);
  626.             } else if (year-- > cal.minYear) {
  627.                 date.setFullYear(year);
  628.                 setMonth(11);
  629.             }
  630.             break;
  631.             case 1:
  632.             if (mon < 11) {
  633.                 setMonth(mon + 1);
  634.             } else if (year < cal.maxYear) {
  635.                 date.setFullYear(year + 1);
  636.                 setMonth(0);
  637.             }
  638.             break;
  639.             case 2:
  640.             if (year < cal.maxYear) {
  641.                 date.setFullYear(year + 1);
  642.             }
  643.             break;
  644.             case 100:
  645.             cal.setFirstDayOfWeek(el.fdow);
  646.             return;
  647.             case 50:
  648.             var range = el._range;
  649.             var current = el.firstChild.data;
  650.             for (var i = range.length; --i >= 0;)
  651.                 if (range[i] == current)
  652.                     break;
  653.             if (ev && ev.shiftKey) {
  654.                 if (--i < 0)
  655.                     i = range.length - 1;
  656.             } else if ( ++i >= range.length )
  657.                 i = 0;
  658.             var newval = range[i];
  659.             el.firstChild.data = newval;
  660.             cal.onUpdateTime();
  661.             return;
  662.             case 0:
  663.             // TODAY will bring us here
  664.             if ((typeof cal.getDateStatus == "function") && cal.getDateStatus(date, date.getFullYear(), date.getMonth(), date.getDate())) {
  665.                 // remember, "date" was previously set to new
  666.                 // Date() if TODAY was clicked; thus, it
  667.                 // contains today date.
  668.                 return false;
  669.             }
  670.             break;
  671.         }
  672.         if (!date.equalsTo(cal.date)) {
  673.             cal.setDate(date);
  674.             newdate = true;
  675.         }
  676.     }
  677.     if (newdate) {
  678.         cal.callHandler();
  679.     }
  680.     if (closing) {
  681.         Calendar.removeClass(el, "hilite");
  682.         cal.callCloseHandler();
  683.     }
  684. };
  685.  
  686. // END: CALENDAR STATIC FUNCTIONS
  687.  
  688. // BEGIN: CALENDAR OBJECT FUNCTIONS
  689.  
  690. /**
  691.  *  This function creates the calendar inside the given parent.  If _par is
  692.  *  null than it creates a popup calendar inside the BODY element.  If _par is
  693.  *  an element, be it BODY, then it creates a non-popup calendar (still
  694.  *  hidden).  Some properties need to be set before calling this function.
  695.  */
  696. Calendar.prototype.create = function (_par) {
  697.     var parent = null;
  698.     if (! _par) {
  699.         // default parent is the document body, in which case we create
  700.         // a popup calendar.
  701.         parent = document.getElementsByTagName("body")[0];
  702.         this.isPopup = true;
  703.     } else {
  704.         parent = _par;
  705.         this.isPopup = false;
  706.     }
  707.     this.date = this.dateStr ? new Date(this.dateStr) : new Date();
  708.  
  709.     var table = Calendar.createElement("table");
  710.     this.table = table;
  711.     table.cellSpacing = 0;
  712.     table.cellPadding = 0;
  713.     table.calendar = this;
  714.     Calendar.addEvent(table, "mousedown", Calendar.tableMouseDown);
  715.  
  716.     var div = Calendar.createElement("div");
  717.     this.element = div;
  718.     div.className = "calendar";
  719.     if (this.isPopup) {
  720.         div.style.position = "absolute";
  721.         div.style.display = "none";
  722.     }
  723.     div.appendChild(table);
  724.  
  725.     var thead = Calendar.createElement("thead", table);
  726.     var cell = null;
  727.     var row = null;
  728.  
  729.     var cal = this;
  730.     var hh = function (text, cs, navtype) {
  731.         cell = Calendar.createElement("td", row);
  732.         cell.colSpan = cs;
  733.         cell.className = "button";
  734.         if (navtype != 0 && Math.abs(navtype) <= 2)
  735.             cell.className += " nav";
  736.         Calendar._add_evs(cell);
  737.         cell.calendar = cal;
  738.         cell.navtype = navtype;
  739.         if (text.substr(0, 1) != "&") {
  740.             cell.appendChild(document.createTextNode(text));
  741.         }
  742.         else {
  743.             // FIXME: dirty hack for entities
  744.             cell.innerHTML = text;
  745.         }
  746.         return cell;
  747.     };
  748.  
  749.     row = Calendar.createElement("tr", thead);
  750.     var title_length = 6;
  751.     (this.isPopup) && --title_length;
  752.     (this.weekNumbers) && ++title_length;
  753.  
  754.     //hh("", 1, 400).ttip = Calendar._TT["INFO"];
  755.     this.title = hh("", title_length+1, 300);
  756.     this.title.className = "title";
  757.     if (this.isPopup) {
  758.         this.title.ttip = Calendar._TT["DRAG_TO_MOVE"];
  759.         this.title.style.cursor = "move";
  760.         hh("×", 1, 200).ttip = Calendar._TT["CLOSE"];
  761.     }
  762.  
  763.     row = Calendar.createElement("tr", thead);
  764.     row.className = "headrow";
  765.  
  766.     this._nav_py = hh("«", 1, -2);
  767.     this._nav_py.ttip = Calendar._TT["PREV_YEAR"];
  768.  
  769.     this._nav_pm = hh("‹", 1, -1);
  770.     this._nav_pm.ttip = Calendar._TT["PREV_MONTH"];
  771.  
  772.     this._nav_now = hh(Calendar._TT["TODAY"], this.weekNumbers ? 4 : 3, 0);
  773.     this._nav_now.ttip = Calendar._TT["GO_TODAY"];
  774.  
  775.     this._nav_nm = hh("›", 1, 1);
  776.     this._nav_nm.ttip = Calendar._TT["NEXT_MONTH"];
  777.  
  778.     this._nav_ny = hh("»", 1, 2);
  779.     this._nav_ny.ttip = Calendar._TT["NEXT_YEAR"];
  780.  
  781.     // day names
  782.     row = Calendar.createElement("tr", thead);
  783.     row.className = "daynames";
  784.     if (this.weekNumbers) {
  785.         cell = Calendar.createElement("td", row);
  786.         cell.className = "name wn";
  787.         cell.appendChild(document.createTextNode(Calendar._TT["WK"]));
  788.     }
  789.     for (var i = 7; i > 0; --i) {
  790.         cell = Calendar.createElement("td", row);
  791.         cell.appendChild(document.createTextNode(""));
  792.         if (!i) {
  793.             cell.navtype = 100;
  794.             cell.calendar = this;
  795.             Calendar._add_evs(cell);
  796.         }
  797.     }
  798.     this.firstdayname = (this.weekNumbers) ? row.firstChild.nextSibling : row.firstChild;
  799.     this._displayWeekdays();
  800.  
  801.     var tbody = Calendar.createElement("tbody", table);
  802.     this.tbody = tbody;
  803.  
  804.     for (i = 6; i > 0; --i) {
  805.         row = Calendar.createElement("tr", tbody);
  806.         if (this.weekNumbers) {
  807.             cell = Calendar.createElement("td", row);
  808.             cell.appendChild(document.createTextNode(""));
  809.         }
  810.         for (var j = 7; j > 0; --j) {
  811.             cell = Calendar.createElement("td", row);
  812.             cell.appendChild(document.createTextNode(""));
  813.             cell.calendar = this;
  814.             Calendar._add_evs(cell);
  815.         }
  816.     }
  817.  
  818.     if (this.showsTime) {
  819.         row = Calendar.createElement("tr", tbody);
  820.         row.className = "time";
  821.  
  822.         cell = Calendar.createElement("td", row);
  823.         cell.className = "time";
  824.         cell.colSpan = 2;
  825.         cell.innerHTML = Calendar._TT["TIME"] || " ";
  826.  
  827.         cell = Calendar.createElement("td", row);
  828.         cell.className = "time";
  829.         cell.colSpan = this.weekNumbers ? 4 : 3;
  830.  
  831.         (function(){
  832.             function makeTimePart(className, init, range_start, range_end) {
  833.                 var part = Calendar.createElement("span", cell);
  834.                 part.className = className;
  835.                 part.appendChild(document.createTextNode(init));
  836.                 part.calendar = cal;
  837.                 part.ttip = Calendar._TT["TIME_PART"];
  838.                 part.navtype = 50;
  839.                 part._range = [];
  840.                 if (typeof range_start != "number")
  841.                     part._range = range_start;
  842.                 else {
  843.                     for (var i = range_start; i <= range_end; ++i) {
  844.                         var txt;
  845.                         if (i < 10 && range_end >= 10) txt = '0' + i;
  846.                         else txt = '' + i;
  847.                         part._range[part._range.length] = txt;
  848.                     }
  849.                 }
  850.                 Calendar._add_evs(part);
  851.                 return part;
  852.             };
  853.             var hrs = cal.date.getHours();
  854.             var mins = cal.date.getMinutes();
  855.             var t12 = !cal.time24;
  856.             var pm = (hrs > 12);
  857.             if (t12 && pm) hrs -= 12;
  858.             var H = makeTimePart("hour", hrs, t12 ? 1 : 0, t12 ? 12 : 23);
  859.             var span = Calendar.createElement("span", cell);
  860.             span.appendChild(document.createTextNode(":"));
  861.             span.className = "colon";
  862.             var M = makeTimePart("minute", mins, 0, 59);
  863.             var AP = null;
  864.             cell = Calendar.createElement("td", row);
  865.             cell.className = "time";
  866.             cell.colSpan = 2;
  867.             if (t12)
  868.                 AP = makeTimePart("ampm", pm ? "pm" : "am", ["am", "pm"]);
  869.             else
  870.                 cell.innerHTML = " ";
  871.  
  872.             cal.onSetTime = function() {
  873.                 var hrs = this.date.getHours();
  874.                 var mins = this.date.getMinutes();
  875.                 var pm = (hrs > 12);
  876.                 if (pm && t12) hrs -= 12;
  877.                 H.firstChild.data = (hrs < 10) ? ("0" + hrs) : hrs;
  878.                 M.firstChild.data = (mins < 10) ? ("0" + mins) : mins;
  879.                 if (t12)
  880.                     AP.firstChild.data = pm ? "pm" : "am";
  881.             };
  882.  
  883.             cal.onUpdateTime = function() {
  884.                 var date = this.date;
  885.                 var h = parseInt(H.firstChild.data, 10);
  886.                 if (t12) {
  887.                     if (/pm/i.test(AP.firstChild.data) && h < 12)
  888.                         h += 12;
  889.                     else if (/am/i.test(AP.firstChild.data) && h == 12)
  890.                         h = 0;
  891.                 }
  892.                 var d = date.getDate();
  893.                 var m = date.getMonth();
  894.                 var y = date.getFullYear();
  895.                 date.setHours(h);
  896.                 date.setMinutes(parseInt(M.firstChild.data, 10));
  897.                 date.setFullYear(y);
  898.                 date.setMonth(m);
  899.                 date.setDate(d);
  900.                 this.dateClicked = false;
  901.                 this.callHandler();
  902.             };
  903.         })();
  904.     } else {
  905.         this.onSetTime = this.onUpdateTime = function() {};
  906.     }
  907.  
  908.     var tfoot = Calendar.createElement("tfoot", table);
  909.  
  910.     row = Calendar.createElement("tr", tfoot);
  911.     row.className = "footrow";
  912.  
  913.     cell = hh(Calendar._TT["SEL_DATE"], this.weekNumbers ? 8 : 7, 300);
  914.     cell.className = "ttip";
  915.     if (this.isPopup) {
  916.         cell.ttip = Calendar._TT["DRAG_TO_MOVE"];
  917.         cell.style.cursor = "move";
  918.     }
  919.     this.tooltips = cell;
  920.  
  921.     div = Calendar.createElement("div", this.element);
  922.     this.monthsCombo = div;
  923.     div.className = "combo";
  924.     for (i = 0; i < Calendar._MN.length; ++i) {
  925.         var mn = Calendar.createElement("div");
  926.         mn.className = Calendar.is_ie ? "label-IEfix" : "label";
  927.         mn.month = i;
  928.         mn.appendChild(document.createTextNode(Calendar._SMN[i]));
  929.         div.appendChild(mn);
  930.     }
  931.  
  932.     div = Calendar.createElement("div", this.element);
  933.     this.yearsCombo = div;
  934.     div.className = "combo";
  935.     for (i = 12; i > 0; --i) {
  936.         var yr = Calendar.createElement("div");
  937.         yr.className = Calendar.is_ie ? "label-IEfix" : "label";
  938.         yr.appendChild(document.createTextNode(""));
  939.         div.appendChild(yr);
  940.     }
  941.  
  942.     this._init(this.firstDayOfWeek, this.date);
  943.     parent.appendChild(this.element);
  944. };
  945.  
  946. /** keyboard navigation, only for popup calendars */
  947. Calendar._keyEvent = function(ev) {
  948.     if (!window.calendar) {
  949.         return false;
  950.     }
  951.     (Calendar.is_ie) && (ev = window.event);
  952.     var cal = window.calendar;
  953.     var act = (Calendar.is_ie || ev.type == "keypress");
  954.     if (ev.ctrlKey) {
  955.         switch (ev.keyCode) {
  956.             case 37: // KEY left
  957.             act && Calendar.cellClick(cal._nav_pm);
  958.             break;
  959.             case 38: // KEY up
  960.             act && Calendar.cellClick(cal._nav_py);
  961.             break;
  962.             case 39: // KEY right
  963.             act && Calendar.cellClick(cal._nav_nm);
  964.             break;
  965.             case 40: // KEY down
  966.             act && Calendar.cellClick(cal._nav_ny);
  967.             break;
  968.             default:
  969.             return false;
  970.         }
  971.     } else switch (ev.keyCode) {
  972.         case 32: // KEY space (now)
  973.         Calendar.cellClick(cal._nav_now);
  974.         break;
  975.         case 27: // KEY esc
  976.         act && cal.callCloseHandler();
  977.         break;
  978.         case 37: // KEY left
  979.         case 38: // KEY up
  980.         case 39: // KEY right
  981.         case 40: // KEY down
  982.         if (act) {
  983.             var date = cal.date.getDate() - 1;
  984.             var el = cal.currentDateEl;
  985.             var ne = null;
  986.             var prev = (ev.keyCode == 37) || (ev.keyCode == 38);
  987.             switch (ev.keyCode) {
  988.                 case 37: // KEY left
  989.                 (--date >= 0) && (ne = cal.ar_days[date]);
  990.                 break;
  991.                 case 38: // KEY up
  992.                 date -= 7;
  993.                 (date >= 0) && (ne = cal.ar_days[date]);
  994.                 break;
  995.                 case 39: // KEY right
  996.                 (++date < cal.ar_days.length) && (ne = cal.ar_days[date]);
  997.                 break;
  998.                 case 40: // KEY down
  999.                 date += 7;
  1000.                 (date < cal.ar_days.length) && (ne = cal.ar_days[date]);
  1001.                 break;
  1002.             }
  1003.             if (!ne) {
  1004.                 if (prev) {
  1005.                     Calendar.cellClick(cal._nav_pm);
  1006.                 } else {
  1007.                     Calendar.cellClick(cal._nav_nm);
  1008.                 }
  1009.                 date = (prev) ? cal.date.getMonthDays() : 1;
  1010.                 el = cal.currentDateEl;
  1011.                 ne = cal.ar_days[date - 1];
  1012.             }
  1013.             Calendar.removeClass(el, "selected");
  1014.             Calendar.addClass(ne, "selected");
  1015.             cal.date = new Date(ne.caldate);
  1016.             cal.callHandler();
  1017.             cal.currentDateEl = ne;
  1018.         }
  1019.         break;
  1020.         case 13: // KEY enter
  1021.         if (act) {
  1022.             cal.callHandler();
  1023.             cal.hide();
  1024.         }
  1025.         break;
  1026.         default:
  1027.         return false;
  1028.     }
  1029.     return Calendar.stopEvent(ev);
  1030. };
  1031.  
  1032. /**
  1033.  *  (RE)Initializes the calendar to the given date and firstDayOfWeek
  1034.  */
  1035. Calendar.prototype._init = function (firstDayOfWeek, date) {
  1036.     var today = new Date();
  1037.     this.table.style.visibility = "hidden";
  1038.     var year = date.getFullYear();
  1039.     if (year < this.minYear) {
  1040.         year = this.minYear;
  1041.         date.setFullYear(year);
  1042.     } else if (year > this.maxYear) {
  1043.         year = this.maxYear;
  1044.         date.setFullYear(year);
  1045.     }
  1046.     this.firstDayOfWeek = firstDayOfWeek;
  1047.     this.date = new Date(date);
  1048.     var month = date.getMonth();
  1049.     var mday = date.getDate();
  1050.     var no_days = date.getMonthDays();
  1051.  
  1052.     // calendar voodoo for computing the first day that would actually be
  1053.     // displayed in the calendar, even if it's from the previous month.
  1054.     // WARNING: this is magic. ;-)
  1055.     date.setDate(1);
  1056.     var day1 = (date.getDay() - this.firstDayOfWeek) % 7;
  1057.     if (day1 < 0)
  1058.         day1 += 7;
  1059.     date.setDate(-day1);
  1060.     date.setDate(date.getDate() + 1);
  1061.  
  1062.     var row = this.tbody.firstChild;
  1063.     var MN = Calendar._SMN[month];
  1064.     var ar_days = new Array();
  1065.     var weekend = Calendar._TT["WEEKEND"];
  1066.     for (var i = 0; i < 6; ++i, row = row.nextSibling) {
  1067.         var cell = row.firstChild;
  1068.         if (this.weekNumbers) {
  1069.             cell.className = "day wn";
  1070.             cell.firstChild.data = date.getWeekNumber();
  1071.             cell = cell.nextSibling;
  1072.         }
  1073.         row.className = "daysrow";
  1074.         var hasdays = false;
  1075.         for (var j = 0; j < 7; ++j, cell = cell.nextSibling, date.setDate(date.getDate() + 1)) {
  1076.             var iday = date.getDate();
  1077.             var wday = date.getDay();
  1078.             cell.className = "day";
  1079.             var current_month = (date.getMonth() == month);
  1080.             if (!current_month) {
  1081.                 if (this.showsOtherMonths) {
  1082.                     cell.className += " othermonth";
  1083.                     cell.otherMonth = true;
  1084.                 } else {
  1085.                     cell.className = "emptycell";
  1086.                     cell.innerHTML = " ";
  1087.                     cell.disabled = true;
  1088.                     continue;
  1089.                 }
  1090.             } else {
  1091.                 cell.otherMonth = false;
  1092.                 hasdays = true;
  1093.             }
  1094.             cell.disabled = false;
  1095.             cell.firstChild.data = iday;
  1096.             if (typeof this.getDateStatus == "function") {
  1097.                 var status = this.getDateStatus(date, year, month, iday);
  1098.                 if (status === true) {
  1099.                     cell.className += " disabled";
  1100.                     cell.disabled = true;
  1101.                 } else {
  1102.                     if (/disabled/i.test(status))
  1103.                         cell.disabled = true;
  1104.                     cell.className += " " + status;
  1105.                 }
  1106.             }
  1107.             if (!cell.disabled) {
  1108.                 ar_days[ar_days.length] = cell;
  1109.                 cell.caldate = new Date(date);
  1110.                 cell.ttip = "_";
  1111.                 if (current_month && iday == mday) {
  1112.                     cell.className += " selected";
  1113.                     this.currentDateEl = cell;
  1114.                 }
  1115.                 if (date.getFullYear() == today.getFullYear() &&
  1116.                     date.getMonth() == today.getMonth() &&
  1117.                     iday == today.getDate()) {
  1118.                     cell.className += " today";
  1119.                     cell.ttip += Calendar._TT["PART_TODAY"];
  1120.                 }
  1121.                 if (weekend.indexOf(wday.toString()) != -1) {
  1122.                     cell.className += cell.otherMonth ? " oweekend" : " weekend";
  1123.                 }
  1124.             }
  1125.         }
  1126.         if (!(hasdays || this.showsOtherMonths))
  1127.             row.className = "emptyrow";
  1128.     }
  1129.     this.ar_days = ar_days;
  1130.     this.title.firstChild.data = Calendar._MN[month] + ", " + year;
  1131.     this.onSetTime();
  1132.     this.table.style.visibility = "visible";
  1133.     // PROFILE
  1134.     // this.tooltips.firstChild.data = "Generated in " + ((new Date()) - today) + " ms";
  1135. };
  1136.  
  1137. /**
  1138.  *  Calls _init function above for going to a certain date (but only if the
  1139.  *  date is different than the currently selected one).
  1140.  */
  1141. Calendar.prototype.setDate = function (date) {
  1142.     if (!date.equalsTo(this.date)) {
  1143.         this._init(this.firstDayOfWeek, date);
  1144.     }
  1145. };
  1146.  
  1147. /**
  1148.  *  Refreshes the calendar.  Useful if the "disabledHandler" function is
  1149.  *  dynamic, meaning that the list of disabled date can change at runtime.
  1150.  *  Just * call this function if you think that the list of disabled dates
  1151.  *  should * change.
  1152.  */
  1153. Calendar.prototype.refresh = function () {
  1154.     this._init(this.firstDayOfWeek, this.date);
  1155. };
  1156.  
  1157. /** Modifies the "firstDayOfWeek" parameter (pass 0 for Synday, 1 for Monday, etc.). */
  1158. Calendar.prototype.setFirstDayOfWeek = function (firstDayOfWeek) {
  1159.     this._init(firstDayOfWeek, this.date);
  1160.     this._displayWeekdays();
  1161. };
  1162.  
  1163. /**
  1164.  *  Allows customization of what dates are enabled.  The "unaryFunction"
  1165.  *  parameter must be a function object that receives the date (as a JS Date
  1166.  *  object) and returns a boolean value.  If the returned value is true then
  1167.  *  the passed date will be marked as disabled.
  1168.  */
  1169. Calendar.prototype.setDateStatusHandler = Calendar.prototype.setDisabledHandler = function (unaryFunction) {
  1170.     this.getDateStatus = unaryFunction;
  1171. };
  1172.  
  1173. /** Customization of allowed year range for the calendar. */
  1174. Calendar.prototype.setRange = function (a, z) {
  1175.     this.minYear = a;
  1176.     this.maxYear = z;
  1177. };
  1178.  
  1179. /** Calls the first user handler (selectedHandler). */
  1180. Calendar.prototype.callHandler = function () {
  1181.     if (this.onSelected) {
  1182.         this.onSelected(this, this.date.print(this.dateFormat));
  1183.     }
  1184. };
  1185.  
  1186. /** Calls the second user handler (closeHandler). */
  1187. Calendar.prototype.callCloseHandler = function () {
  1188.     if (this.onClose) {
  1189.         this.onClose(this);
  1190.     }
  1191.     this.hideShowCovered();
  1192. };
  1193.  
  1194. /** Removes the calendar object from the DOM tree and destroys it. */
  1195. Calendar.prototype.destroy = function () {
  1196.     var el = this.element.parentNode;
  1197.     el.removeChild(this.element);
  1198.     Calendar._C = null;
  1199.     window.calendar = null;
  1200. };
  1201.  
  1202. /**
  1203.  *  Moves the calendar element to a different section in the DOM tree (changes
  1204.  *  its parent).
  1205.  */
  1206. Calendar.prototype.reparent = function (new_parent) {
  1207.     var el = this.element;
  1208.     el.parentNode.removeChild(el);
  1209.     new_parent.appendChild(el);
  1210. };
  1211.  
  1212. // This gets called when the user presses a mouse button anywhere in the
  1213. // document, if the calendar is shown.  If the click was outside the open
  1214. // calendar this function closes it.
  1215. Calendar._checkCalendar = function(ev) {
  1216.     if (!window.calendar) {
  1217.         return false;
  1218.     }
  1219.     var el = Calendar.is_ie ? Calendar.getElement(ev) : Calendar.getTargetElement(ev);
  1220.     for (; el != null && el != calendar.element; el = el.parentNode);
  1221.     if (el == null) {
  1222.         // calls closeHandler which should hide the calendar.
  1223.         window.calendar.callCloseHandler();
  1224.         return Calendar.stopEvent(ev);
  1225.     }
  1226. };
  1227.  
  1228. /** Shows the calendar. */
  1229. Calendar.prototype.show = function () {
  1230.     var rows = this.table.getElementsByTagName("tr");
  1231.     for (var i = rows.length; i > 0;) {
  1232.         var row = rows[--i];
  1233.         Calendar.removeClass(row, "rowhilite");
  1234.         var cells = row.getElementsByTagName("td");
  1235.         for (var j = cells.length; j > 0;) {
  1236.             var cell = cells[--j];
  1237.             Calendar.removeClass(cell, "hilite");
  1238.             Calendar.removeClass(cell, "active");
  1239.         }
  1240.     }
  1241.     this.element.style.display = "block";
  1242.     this.hidden = false;
  1243.     if (this.isPopup) {
  1244.         window.calendar = this;
  1245.         Calendar.addEvent(document, "keydown", Calendar._keyEvent);
  1246.         Calendar.addEvent(document, "keypress", Calendar._keyEvent);
  1247.         Calendar.addEvent(document, "mousedown", Calendar._checkCalendar);
  1248.     }
  1249.     this.hideShowCovered();
  1250. };
  1251.  
  1252. /**
  1253.  *  Hides the calendar.  Also removes any "hilite" from the class of any TD
  1254.  *  element.
  1255.  */
  1256. Calendar.prototype.hide = function () {
  1257.     if (this.isPopup) {
  1258.         Calendar.removeEvent(document, "keydown", Calendar._keyEvent);
  1259.         Calendar.removeEvent(document, "keypress", Calendar._keyEvent);
  1260.         Calendar.removeEvent(document, "mousedown", Calendar._checkCalendar);
  1261.     }
  1262.     this.element.style.display = "none";
  1263.     this.hidden = true;
  1264.     this.hideShowCovered();
  1265. };
  1266.  
  1267. /**
  1268.  *  Shows the calendar at a given absolute position (beware that, depending on
  1269.  *  the calendar element style -- position property -- this might be relative
  1270.  *  to the parent's containing rectangle).
  1271.  */
  1272. Calendar.prototype.showAt = function (x, y) {
  1273.     var s = this.element.style;
  1274.     s.left = x + "px";
  1275.     s.top = y + "px";
  1276.     this.show();
  1277. };
  1278.  
  1279. /** Shows the calendar near a given element. */
  1280. Calendar.prototype.showAtElement = function (el, opts) {
  1281.     var self = this;
  1282.     var p = Calendar.getAbsolutePos(el);
  1283.     if (!opts || typeof opts != "string") {
  1284.         this.showAt(p.x, p.y + el.offsetHeight);
  1285.         return true;
  1286.     }
  1287.     function fixPosition(box) {
  1288.         if (box.x < 0)
  1289.             box.x = 0;
  1290.         if (box.y < 0)
  1291.             box.y = 0;
  1292.         var cp = document.createElement("div");
  1293.         var s = cp.style;
  1294.         s.position = "absolute";
  1295.         s.right = s.bottom = s.width = s.height = "0px";
  1296.         document.body.appendChild(cp);
  1297.         var br = Calendar.getAbsolutePos(cp);
  1298.         document.body.removeChild(cp);
  1299.         if (Calendar.is_ie) {
  1300.             br.y += document.body.scrollTop;
  1301.             br.x += document.body.scrollLeft;
  1302.         } else {
  1303.             br.y += window.scrollY;
  1304.             br.x += window.scrollX;
  1305.         }
  1306.         var tmp = box.x + box.width - br.x;
  1307.         if (tmp > 0) box.x -= tmp;
  1308.         tmp = box.y + box.height - br.y;
  1309.         if (tmp > 0) box.y -= tmp;
  1310.     };
  1311.     this.element.style.display = "block";
  1312.     Calendar.continuation_for_the_fucking_khtml_browser = function() {
  1313.         var w = self.element.offsetWidth;
  1314.         var h = self.element.offsetHeight;
  1315.         self.element.style.display = "none";
  1316.         var valign = opts.substr(0, 1);
  1317.         var halign = "l";
  1318.         if (opts.length > 1) {
  1319.             halign = opts.substr(1, 1);
  1320.         }
  1321.         // vertical alignment
  1322.         switch (valign) {
  1323.             case "T": p.y -= h; break;
  1324.             case "B": p.y += el.offsetHeight; break;
  1325.             case "C": p.y += (el.offsetHeight - h) / 2; break;
  1326.             case "t": p.y += el.offsetHeight - h; break;
  1327.             case "b": break; // already there
  1328.         }
  1329.         // horizontal alignment
  1330.         switch (halign) {
  1331.             case "L": p.x -= w; break;
  1332.             case "R": p.x += el.offsetWidth; break;
  1333.             case "C": p.x += (el.offsetWidth - w) / 2; break;
  1334.             case "r": p.x += el.offsetWidth - w; break;
  1335.             case "l": break; // already there
  1336.         }
  1337.         p.width = w;
  1338.         p.height = h + 40;
  1339.         self.monthsCombo.style.display = "none";
  1340.         fixPosition(p);
  1341.         self.showAt(p.x, p.y);
  1342.     };
  1343.     if (Calendar.is_khtml)
  1344.         setTimeout("Calendar.continuation_for_the_fucking_khtml_browser()", 10);
  1345.     else
  1346.         Calendar.continuation_for_the_fucking_khtml_browser();
  1347. };
  1348.  
  1349. /** Customizes the date format. */
  1350. Calendar.prototype.setDateFormat = function (str) {
  1351.     this.dateFormat = str;
  1352. };
  1353.  
  1354. /** Customizes the tooltip date format. */
  1355. Calendar.prototype.setTtDateFormat = function (str) {
  1356.     this.ttDateFormat = str;
  1357. };
  1358.  
  1359. /**
  1360.  *  Tries to identify the date represented in a string.  If successful it also
  1361.  *  calls this.setDate which moves the calendar to the given date.
  1362.  */
  1363. Calendar.prototype.parseDate = function (str, fmt) {
  1364.     var y = 0;
  1365.     var m = -1;
  1366.     var d = 0;
  1367.     var a = str.split(/\W+/);
  1368.     if (!fmt) {
  1369.         fmt = this.dateFormat;
  1370.     }
  1371.     var b = fmt.match(/%./g);
  1372.     var i = 0, j = 0;
  1373.     var hr = 0;
  1374.     var min = 0;
  1375.     for (i = 0; i < a.length; ++i) {
  1376.         if (!a[i])
  1377.             continue;
  1378.         switch (b[i]) {
  1379.             case "%d":
  1380.             case "%e":
  1381.             d = parseInt(a[i], 10);
  1382.             break;
  1383.  
  1384.             case "%m":
  1385.             m = parseInt(a[i], 10) - 1;
  1386.             break;
  1387.  
  1388.             case "%Y":
  1389.             case "%y":
  1390.             y = parseInt(a[i], 10);
  1391.             (y < 100) && (y += (y > 29) ? 1900 : 2000);
  1392.             break;
  1393.  
  1394.             case "%b":
  1395.             case "%B":
  1396.             for (j = 0; j < 12; ++j) {
  1397.                 if (Calendar._MN[j].substr(0, a[i].length).toLowerCase() == a[i].toLowerCase()) { m = j; break; }
  1398.             }
  1399.             break;
  1400.  
  1401.             case "%H":
  1402.             case "%I":
  1403.             case "%k":
  1404.             case "%l":
  1405.             hr = parseInt(a[i], 10);
  1406.             break;
  1407.  
  1408.             case "%P":
  1409.             case "%p":
  1410.             if (/pm/i.test(a[i]) && hr < 12)
  1411.                 hr += 12;
  1412.             break;
  1413.  
  1414.             case "%M":
  1415.             min = parseInt(a[i], 10);
  1416.             break;
  1417.         }
  1418.     }
  1419.     if (y != 0 && m != -1 && d != 0) {
  1420.         this.setDate(new Date(y, m, d, hr, min, 0));
  1421.         return;
  1422.     }
  1423.     y = 0; m = -1; d = 0;
  1424.     for (i = 0; i < a.length; ++i) {
  1425.         if (a[i].search(/[a-zA-Z]+/) != -1) {
  1426.             var t = -1;
  1427.             for (j = 0; j < 12; ++j) {
  1428.                 if (Calendar._MN[j].substr(0, a[i].length).toLowerCase() == a[i].toLowerCase()) { t = j; break; }
  1429.             }
  1430.             if (t != -1) {
  1431.                 if (m != -1) {
  1432.                     d = m+1;
  1433.                 }
  1434.                 m = t;
  1435.             }
  1436.         } else if (parseInt(a[i], 10) <= 12 && m == -1) {
  1437.             m = a[i]-1;
  1438.         } else if (parseInt(a[i], 10) > 31 && y == 0) {
  1439.             y = parseInt(a[i], 10);
  1440.             (y < 100) && (y += (y > 29) ? 1900 : 2000);
  1441.         } else if (d == 0) {
  1442.             d = a[i];
  1443.         }
  1444.     }
  1445.     if (y == 0) {
  1446.         var today = new Date();
  1447.         y = today.getFullYear();
  1448.     }
  1449.     if (m != -1 && d != 0) {
  1450.         this.setDate(new Date(y, m, d, hr, min, 0));
  1451.     }
  1452. };
  1453.  
  1454. Calendar.prototype.hideShowCovered = function () {
  1455.     var self = this;
  1456.     Calendar.continuation_for_the_fucking_khtml_browser = function() {
  1457.         function getVisib(obj){
  1458.             var value = obj.style.visibility;
  1459.             if (!value) {
  1460.                 if (document.defaultView && typeof (document.defaultView.getComputedStyle) == "function") { // Gecko, W3C
  1461.                     if (!Calendar.is_khtml)
  1462.                         value = document.defaultView.
  1463.                             getComputedStyle(obj, "").getPropertyValue("visibility");
  1464.                     else
  1465.                         value = '';
  1466.                 } else if (obj.currentStyle) { // IE
  1467.                     value = obj.currentStyle.visibility;
  1468.                 } else
  1469.                     value = '';
  1470.             }
  1471.             return value;
  1472.         };
  1473.  
  1474.         var tags = new Array("applet", "iframe", "select");
  1475.         var el = self.element;
  1476.  
  1477.         var p = Calendar.getAbsolutePos(el);
  1478.         var EX1 = p.x;
  1479.         var EX2 = el.offsetWidth + EX1;
  1480.         var EY1 = p.y;
  1481.         var EY2 = el.offsetHeight + EY1;
  1482.  
  1483.         for (var k = tags.length; k > 0; ) {
  1484.             var ar = document.getElementsByTagName(tags[--k]);
  1485.             var cc = null;
  1486.  
  1487.             for (var i = ar.length; i > 0;) {
  1488.                 cc = ar[--i];
  1489.  
  1490.                 p = Calendar.getAbsolutePos(cc);
  1491.                 var CX1 = p.x;
  1492.                 var CX2 = cc.offsetWidth + CX1;
  1493.                 var CY1 = p.y;
  1494.                 var CY2 = cc.offsetHeight + CY1;
  1495.  
  1496.                 if (self.hidden || (CX1 > EX2) || (CX2 < EX1) || (CY1 > EY2) || (CY2 < EY1)) {
  1497.                     if (!cc.__msh_save_visibility) {
  1498.                         cc.__msh_save_visibility = getVisib(cc);
  1499.                     }
  1500.                     cc.style.visibility = cc.__msh_save_visibility;
  1501.                 } else {
  1502.                     if (!cc.__msh_save_visibility) {
  1503.                         cc.__msh_save_visibility = getVisib(cc);
  1504.                     }
  1505.                     cc.style.visibility = "hidden";
  1506.                 }
  1507.             }
  1508.         }
  1509.     };
  1510.     if (Calendar.is_khtml)
  1511.         setTimeout("Calendar.continuation_for_the_fucking_khtml_browser()", 10);
  1512.     else
  1513.         Calendar.continuation_for_the_fucking_khtml_browser();
  1514. };
  1515.  
  1516. /** Internal function; it displays the bar with the names of the weekday. */
  1517. Calendar.prototype._displayWeekdays = function () {
  1518.     var fdow = this.firstDayOfWeek;
  1519.     var cell = this.firstdayname;
  1520.     var weekend = Calendar._TT["WEEKEND"];
  1521.     for (var i = 0; i < 7; ++i) {
  1522.         cell.className = "day name";
  1523.         var realday = (i + fdow) % 7;
  1524.         if (i) {
  1525.             cell.ttip = Calendar._TT["DAY_FIRST"].replace("%s", Calendar._DN[realday]);
  1526.             cell.navtype = 100;
  1527.             cell.calendar = this;
  1528.             cell.fdow = realday;
  1529.             Calendar._add_evs(cell);
  1530.         }
  1531.         if (weekend.indexOf(realday.toString()) != -1) {
  1532.             Calendar.addClass(cell, "weekend");
  1533.         }
  1534.         cell.firstChild.data = Calendar._SDN[(i + fdow) % 7];
  1535.         cell = cell.nextSibling;
  1536.     }
  1537. };
  1538.  
  1539. /** Internal function.  Hides all combo boxes that might be displayed. */
  1540. Calendar.prototype._hideCombos = function () {
  1541.     this.monthsCombo.style.display = "none";
  1542.     this.yearsCombo.style.display = "none";
  1543. };
  1544.  
  1545. /** Internal function.  Starts dragging the element. */
  1546. Calendar.prototype._dragStart = function (ev) {
  1547.     if (this.dragging) {
  1548.         return;
  1549.     }
  1550.     this.dragging = true;
  1551.     var posX;
  1552.     var posY;
  1553.     if (Calendar.is_ie) {
  1554.         posY = window.event.clientY + document.body.scrollTop;
  1555.         posX = window.event.clientX + document.body.scrollLeft;
  1556.     } else {
  1557.         posY = ev.clientY + window.scrollY;
  1558.         posX = ev.clientX + window.scrollX;
  1559.     }
  1560.     var st = this.element.style;
  1561.     this.xOffs = posX - parseInt(st.left);
  1562.     this.yOffs = posY - parseInt(st.top);
  1563.     with (Calendar) {
  1564.         addEvent(document, "mousemove", calDragIt);
  1565.         addEvent(document, "mouseup", calDragEnd);
  1566.     }
  1567. };
  1568.  
  1569. // BEGIN: DATE OBJECT PATCHES
  1570.  
  1571. /** Adds the number of days array to the Date object. */
  1572. Date._MD = new Array(31,28,31,30,31,30,31,31,30,31,30,31);
  1573.  
  1574. /** Constants used for time computations */
  1575. Date.SECOND = 1000 /* milliseconds */;
  1576. Date.MINUTE = 60 * Date.SECOND;
  1577. Date.HOUR   = 60 * Date.MINUTE;
  1578. Date.DAY    = 24 * Date.HOUR;
  1579. Date.WEEK   =  7 * Date.DAY;
  1580.  
  1581. /** Returns the number of days in the current month */
  1582. Date.prototype.getMonthDays = function(month) {
  1583.     var year = this.getFullYear();
  1584.     if (typeof month == "undefined") {
  1585.         month = this.getMonth();
  1586.     }
  1587.     if (((0 == (year%4)) && ( (0 != (year%100)) || (0 == (year%400)))) && month == 1) {
  1588.         return 29;
  1589.     } else {
  1590.         return Date._MD[month];
  1591.     }
  1592. };
  1593.  
  1594. /** Returns the number of day in the year. */
  1595. Date.prototype.getDayOfYear = function() {
  1596.     var now = new Date(this.getFullYear(), this.getMonth(), this.getDate(), 0, 0, 0);
  1597.     var then = new Date(this.getFullYear(), 0, 0, 0, 0, 0);
  1598.     var time = now - then;
  1599.     return Math.floor(time / Date.DAY);
  1600. };
  1601.  
  1602. /** Returns the number of the week in year, as defined in ISO 8601. */
  1603. Date.prototype.getWeekNumber = function() {
  1604.     var d = new Date(this.getFullYear(), this.getMonth(), this.getDate(), 0, 0, 0);
  1605.     var DoW = d.getDay();
  1606.     d.setDate(d.getDate() - (DoW + 6) % 7 + 3); // Nearest Thu
  1607.     var ms = d.valueOf(); // GMT
  1608.     d.setMonth(0);
  1609.     d.setDate(4); // Thu in Week 1
  1610.     return Math.round((ms - d.valueOf()) / (7 * 864e5)) + 1;
  1611. };
  1612.  
  1613. /** Checks dates equality (ignores time) */
  1614. Date.prototype.equalsTo = function(date) {
  1615.     return ((this.getFullYear() == date.getFullYear()) &&
  1616.         (this.getMonth() == date.getMonth()) &&
  1617.         (this.getDate() == date.getDate()) &&
  1618.         (this.getHours() == date.getHours()) &&
  1619.         (this.getMinutes() == date.getMinutes()));
  1620. };
  1621.  
  1622. /** Prints the date in a string according to the given format. */
  1623. Date.prototype.print = function (str) {
  1624.     var m = this.getMonth();
  1625.     var d = this.getDate();
  1626.     var y = this.getFullYear();
  1627.     var wn = this.getWeekNumber();
  1628.     var w = this.getDay();
  1629.     var s = {};
  1630.     var hr = this.getHours();
  1631.     var pm = (hr >= 12);
  1632.     var ir = (pm) ? (hr - 12) : hr;
  1633.     var dy = this.getDayOfYear();
  1634.     if (ir == 0)
  1635.         ir = 12;
  1636.     var min = this.getMinutes();
  1637.     var sec = this.getSeconds();
  1638.     s["%a"] = Calendar._SDN[w]; // abbreviated weekday name [FIXME: I18N]
  1639.     s["%A"] = Calendar._DN[w]; // full weekday name
  1640.     s["%b"] = Calendar._SMN[m]; // abbreviated month name [FIXME: I18N]
  1641.     s["%B"] = Calendar._MN[m]; // full month name
  1642.     // FIXME: %c : preferred date and time representation for the current locale
  1643.     s["%C"] = 1 + Math.floor(y / 100); // the century number
  1644.     s["%d"] = (d < 10) ? ("0" + d) : d; // the day of the month (range 01 to 31)
  1645.     s["%e"] = d; // the day of the month (range 1 to 31)
  1646.     // FIXME: %D : american date style: %m/%d/%y
  1647.     // FIXME: %E, %F, %G, %g, %h (man strftime)
  1648.     s["%H"] = (hr < 10) ? ("0" + hr) : hr; // hour, range 00 to 23 (24h format)
  1649.     s["%I"] = (ir < 10) ? ("0" + ir) : ir; // hour, range 01 to 12 (12h format)
  1650.     s["%j"] = (dy < 100) ? ((dy < 10) ? ("00" + dy) : ("0" + dy)) : dy; // day of the year (range 001 to 366)
  1651.     s["%k"] = hr;        // hour, range 0 to 23 (24h format)
  1652.     s["%l"] = ir;        // hour, range 1 to 12 (12h format)
  1653.     s["%m"] = (m < 9) ? ("0" + (1+m)) : (1+m); // month, range 01 to 12
  1654.     s["%M"] = (min < 10) ? ("0" + min) : min; // minute, range 00 to 59
  1655.     s["%n"] = "\n";        // a newline character
  1656.     s["%p"] = pm ? "PM" : "AM";
  1657.     s["%P"] = pm ? "pm" : "am";
  1658.     // FIXME: %r : the time in am/pm notation %I:%M:%S %p
  1659.     // FIXME: %R : the time in 24-hour notation %H:%M
  1660.     s["%s"] = Math.floor(this.getTime() / 1000);
  1661.     s["%S"] = (sec < 10) ? ("0" + sec) : sec; // seconds, range 00 to 59
  1662.     s["%t"] = "\t";        // a tab character
  1663.     // FIXME: %T : the time in 24-hour notation (%H:%M:%S)
  1664.     s["%U"] = s["%W"] = s["%V"] = (wn < 10) ? ("0" + wn) : wn;
  1665.     s["%u"] = w + 1;    // the day of the week (range 1 to 7, 1 = MON)
  1666.     s["%w"] = w;        // the day of the week (range 0 to 6, 0 = SUN)
  1667.     // FIXME: %x : preferred date representation for the current locale without the time
  1668.     // FIXME: %X : preferred time representation for the current locale without the date
  1669.     s["%y"] = ('' + y).substr(2, 2); // year without the century (range 00 to 99)
  1670.     s["%Y"] = y;        // year with the century
  1671.     s["%%"] = "%";        // a literal '%' character
  1672.  
  1673.     var re = /%./g;
  1674.     if (!Calendar.is_ie5)
  1675.         return str.replace(re, function (par) { return s[par] || par; });
  1676.  
  1677.     var a = str.match(re);
  1678.     for (var i = 0; i < a.length; i++) {
  1679.         var tmp = s[a[i]];
  1680.         if (tmp) {
  1681.             re = new RegExp(a[i], 'g');
  1682.             str = str.replace(re, tmp);
  1683.         }
  1684.     }
  1685.  
  1686.     return str;
  1687. };
  1688.  
  1689. Date.prototype.__msh_oldSetFullYear = Date.prototype.setFullYear;
  1690. Date.prototype.setFullYear = function(y) {
  1691.     var d = new Date(this);
  1692.     d.__msh_oldSetFullYear(y);
  1693.     if (d.getMonth() != this.getMonth())
  1694.         this.setDate(28);
  1695.     this.__msh_oldSetFullYear(y);
  1696. };
  1697.  
  1698. // END: DATE OBJECT PATCHES
  1699.  
  1700.  
  1701. // global object that remembers the calendar
  1702. window.calendar = null;
  1703.